import { checkAllCart, deleteCart, findCart, insertCart, mergeCart, updateCart } from '@/api/cart'
import { getNewCartGoods } from '@/api/user'
// import { isClient } from '@vueuse/core'

// 购物车状态
export default {
  namespaced: true,
  state: () => {
    return {
      list: []
    }
  },
  mutations: {
    // 覆盖购物车数据
    setCartList (state, list) {
      state.list = list
    },
    deleteCart (state, skuId) {
      // 查找下标
      const index = state.list.findIndex(item => item.skuId === skuId)
      // 然后切割
      state.list.splice(index, 1)
    },
    updateCart (state, goods) {
      // 查找list里面的id obj就是单个商品查找里面的id和goods里面的id
      // goods是形参 是下面获取接口然后传上来的 item是list的
      /// 如果我传上来的跟呢item.id不一样就没有改动，不需要更新
      // 如果我传上来的跟呢一样就有改动，需要更新
      const obj = state.list.find(item => item.skuId === goods.skuId)
      // 如果没有单个商品
      if (!obj) return
      // 遍历哪里goods里面的key出来
      for (const key in goods) {
        // 排除掉value值为null ||undefined||''
        if (goods[key] !== null && goods[key] !== undefined && goods[key] !== '') {
          obj[key] = goods[key]
        }
      }
    },
    insertCart (state, payload) {
      // 加入购物车
      const index = state.list.findIndex(item => item.skuId === payload.skuId)
      // 下标存在就加数量
      if (index !== -1) {
        state.list[index].count += payload.count
        // 如果不存在就加到购物车第一位，就是另外一个商品
      } else {
        state.list.unshift(payload)
      }
    }
  },
  actions: {
    // 合并购物车
    async mergeLocalCart (store) {
      // 合并购物车
      const data = store.state.list.map(({ skuId, selected, count }) => ({ skuId, selected, count }))
      await mergeCart(data)
      // 获取购物车列表
      const { result } = await findCart()
      // console.log(result)
      store.commit('setCartList', result)
    },
    // 更新购物车规格
    updateCartSku (store, { oldSkuId, newSkuObj }) {
      // 1. 先查找出来商品对象
      const oldSkuObj = store.state.list.find(item => item.skuId === oldSkuId)
      // console.log({ oldSkuObj, newSkuObj })
      // console.log(oldSkuObj)
      // 2. 从列表中删除
      store.commit('deleteCart', oldSkuId)
      // 3. 获取数据并改名更新(因为商品详情页和购物车列表页后端返回的字段名不同)
      const { price: nowPrice, inventory: stock, oldPrice: price, skuId, attrsText } = newSkuObj
      // 4. 合并成完整的购物车商品对象
      store.commit('insertCart', { ...oldSkuObj, nowPrice, stock, price, skuId, attrsText })
    },
    // 批量删除选中商品
    batchDeleteCart (store, isInvalid) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 登录 TODO
          const ids = store.getters[isInvalid === true ? 'invalidList' : 'selectedList'].map(item => item.skuId)
          deleteCart(ids).then(() => {
            store.dispatch('findCartList')
          })
        } else {
          // 本地
          // 1. 获取选中商品列表，进行遍历调用deleteCart mutataions函数
          store.getters.selectedList.forEach(item => {
            store.commit('deleteCart', item.skuId)
          })
          resolve()
        }
      })
    },
    // 全选按钮
    checkAllCart (store, selected) {
      // console.log(selected)
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
          // 登录后 TODO ...
          // 获取每个商品的id

          // 调用接口
          // 1. 已登录 - 发送请求
          const ids = store.getters.validList.map(item => item.skuId)
          checkAllCart({ selected, ids }).then(() => {
            store.dispatch('findCartList')
          })
          resolve('线上接口')
        } else {
          // 情况2：未登录
          store.getters.validList.forEach(item => {
            item.selected = selected
            store.commit('updateCart', item)
          })
          resolve('删除成功,本地操作')
        }
      })
    },
    // 更新购物车商品
    updateCart (store, goods) {
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
          // 登录后 TODO ...
          updateCart(goods).then(() => {
            return findCart()
          }).then((data) => {
            store.commit('setCartList', data.result)
            resolve()
          })

          resolve('线上接口')
        } else {
          // 情况2：未登录
          store.commit('updateCart', goods)
          resolve('删除成功,本地操作')
        }
      })
    },
    // 删除商品
    deleteCart (store, skuId) {
      return new Promise((resolve) => {
        // rootState是整个大仓库找到里面的token
        // 登录了有token就加入购物车
        if (store.rootState.user.profile.token) {
          // store.commit('deleteCart', skuId)
          // resolve('线上接口')
          deleteCart([skuId]).then(() => {
            store.dispatch('findCartList')
          })
        } else {
          store.commit('deleteCart', skuId)
          // 返回去的信息或者值
          resolve('删除成功')
        }
      })
    },
    // 获取购物车列表
    findCartList (store) {
      return new Promise((resolve) => {
        // rootState是整个大仓库找到里面的token
        // 登录了有token就加入购物车
        if (store.rootState.user.profile.token) {
          //
          findCart().then(({ result }) => {
            store.commit('setCartList', result)
          })
        } else {
          // 给到同步方法
          // store.commit('insertCart', payload)
          store.state.list.forEach(async item => {
            const { result } = await getNewCartGoods(item.skuId)
            // 这个skuid是传上去给上面的goosd的
            store.commit('updateCart', { ...result, skuId: item.skuId })
          })
          // 返回去的信息或者值
          resolve('加入购物车成功-本地')
        }
      })
    },
    // 加入购物车
    insertCart  (store, payload) {
      // resolve函数调用后会将Promise对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved）
      // ，在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；
      // reject函数调用后将Promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected）
      // ，在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。
      return new Promise((resolve) => {
        // rootState是整个大仓库找到里面的token
        // 登录了有token就加入购物车
        if (store.rootState.user.profile.token) {
          insertCart(payload).then(() => {
            store.dispatch('findCartList')
          })
        } else {
          // 给到同步方法
          store.commit('insertCart', payload)
          // 返回去的信息或者值
          resolve('加入购物车成功-本地')
        }
      })
    }
  },
  // 相当于计算属性
  getters: {
  // 无效商品列表
    invalidList (state) {
      // stock库存
      return state.list.filter(item => !(item.stock > 0 && item.isEffective))
    },
    // 选中商品列表
    selectedList (state, getters) {
      // selected是否选中
      return getters.validList.filter(item => item.selected)
    },
    // 选中商品件数
    selectedTotal (state, getters) {
      // count数量
      return getters.selectedList.reduce((p, c) => p + c.count, 0)
    },
    // 选中商品总金额
    selectedAmount (state, getters) {
      // nowPrice当前价格
      return getters.selectedList.reduce((p, c) => p + (c.nowPrice * 100 * c.count), 0) / 100
    },
    // 有效商品列表
    validList (state) {
      // stock库存
      return state.list.filter(item => item.stock > 0 && item.isEffective)
    },
    // 是否全选
    isCheckAll (state, getters) {
      // selectedList  list列表
      return getters.selectedList.length !== 0 && getters.validList.length === getters.selectedList.length
    },
    // 有效商品件数
    validTotal (state, getters) {
    // let total = 0
    // getters.validList.forEach(item => {
    //   total += item.count
    // })
    // return total
    // count数量
      return getters.validList.reduce((total, item) => item.count + total, 0)
    },
    // 有效商品总金额
    validAmount (state, getters) {
      // nowPrice当前价格
      // count数量
      return getters.validList.reduce((total, item) => item.nowPrice * 100 * item.count + total, 0) / 100
    }
  }
}
